const { app, BrowserWindow, ipcMain, dialog } = require('electron');
const path = require('path');
const os = require('os');
const fs = require('fs').promises;
const fsSync = require('fs');
const AutoLaunch = require('auto-launch');
const config = require('./config');
const logger = require('./logger');
const websocketClient = require('./websocketClient');
const transferManager = require('./transferManager');
const notificationManager = require('./notificationManager');
const logUploader = require('./logUploader');
const { getInstance: getDatabase } = require('./database');
const avatarManager = require('./avatarManager');
const clientIdManager = require('./clientId'); // 🔥 客户端ID管理器
const systemInfo = require('./systemInfo'); // 🔥 系统信息采集器

// 🔥 拦截控制台输出，确保所有日志都被收集
const originalConsoleLog = console.log;
const originalConsoleError = console.error;
const originalConsoleWarn = console.warn;

console.log = function(...args) {
  originalConsoleLog.apply(console, args);
  const message = args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : String(arg)).join(' ');
  logger.info(message);
};

console.error = function(...args) {
  originalConsoleError.apply(console, args);
  const message = args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : String(arg)).join(' ');
  logger.error(message);
};

console.warn = function(...args) {
  originalConsoleWarn.apply(console, args);
  const message = args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : String(arg)).join(' ');
  logger.warn(message);
};

// 全局错误处理，防止崩溃
process.on('uncaughtException', (error) => {
  logger.error('未捕获的异常:', error);
  originalConsoleError('未捕获的异常:', error);
});

process.on('unhandledRejection', (reason, promise) => {
  logger.error('未处理的Promise拒绝:', reason);
  originalConsoleError('未处理的Promise拒绝:', reason);
});

// 全局状态
let isRestarting = false;

// 配置开机自启（强制启用，不可取消）
const autoLauncher = new AutoLaunch({
  name: '风行融媒体',
  path: app.getPath('exe')
});

// 强制启用开机自启
autoLauncher.isEnabled().then((isEnabled) => {
  if (!isEnabled) {
    autoLauncher.enable();
    logger.info('开机自启已启用');
  }
});

// 应用崩溃自动重启
process.on('uncaughtException', (error) => {
  logger.error('未捕获的异常:', error);
  
  // 保存传输任务状态
  try {
    const state = transferManager.saveState();
    saveTransferState(state);
  } catch (e) {
    logger.error('保存传输状态失败:', e);
  }
  
  if (!isRestarting) {
    isRestarting = true;
    app.relaunch();
    app.exit(0);
  }
});

app.on('render-process-gone', (event, webContents, details) => {
  logger.error('渲染进程崩溃:', details);
  
  // 保存传输任务状态
  try {
    const state = transferManager.saveState();
    saveTransferState(state);
  } catch (e) {
    logger.error('保存传输状态失败:', e);
  }
  
  if (!isRestarting && details.reason === 'crashed') {
    isRestarting = true;
    app.relaunch();
    app.exit(0);
  }
});

let mainWindow = null;
let dbInitialized = false; // 数据库初始化标志
let database = null; // 数据库实例

// 任务恢复：保存传输任务状态
const TRANSFER_STATE_FILE = path.join(app.getPath('userData'), 'transfer_state.json');

// 在应用启动前初始化数据库
function initializeDatabase() {
  try {
    logger.info('开始初始化数据库...');
    database = getDatabase();
    database.initialize();
    
    // 测试数据库写入能力
    const testKey = '_db_test_' + Date.now();
    database.setConfig(testKey, { test: true, timestamp: Date.now() });
    const testValue = database.getConfig(testKey);
    
    if (!testValue || !testValue.test) {
      throw new Error('数据库写入测试失败');
    }
    
    // 清理测试数据
    database.deleteConfig(testKey);
    
    dbInitialized = true;
    logger.info('✅ 数据库初始化成功并通过写入测试');
    return true;
  } catch (error) {
    logger.error('❌ 数据库初始化失败:', error);
    dbInitialized = false;
    database = null;
    return false;
  }
}

// 保存传输状态到数据库
function saveTransferState(state) {
  // 如果数据库未初始化，直接使用JSON文件
  if (!dbInitialized || !database) {
    try {
      fsSync.writeFileSync(TRANSFER_STATE_FILE, JSON.stringify(state, null, 2));
      logger.info('传输状态已保存到JSON文件（数据库未启用）');
    } catch (e) {
      logger.error('保存到JSON文件失败:', e);
    }
    return;
  }

  try {
    if (state && state.queue && state.queue.length > 0) {
      // 🔥 只缓存传输中、暂停、待处理的任务（已完成/失败的会自动上传到服务器）
      const cachedTasks = state.queue.filter(task => 
        task.status === 'active' || 
        task.status === 'pending' || 
        task.status === 'paused'
      );
      
      if (cachedTasks.length > 0) {
        // 保存到JSON文件作为缓存
        const cacheState = {
          queue: cachedTasks,
          maxConcurrent: state.maxConcurrent
        };
        fsSync.writeFileSync(TRANSFER_STATE_FILE, JSON.stringify(cacheState, null, 2));
        logger.info(`💾 传输状态已缓存: ${cachedTasks.length} 个任务 (传输中/待处理/暂停)`);
      } else {
        logger.info('无需缓存的任务（已完成/失败的任务已上传到服务器）');
        // 清空缓存文件
        if (fs.existsSync(TRANSFER_STATE_FILE)) {
          fsSync.unlinkSync(TRANSFER_STATE_FILE);
        }
      }
    } else if (state && state.queue) {
      logger.info('传输队列为空，跳过保存');
    }
  } catch (error) {
    logger.error('保存传输状态缓存失败:', error);
  }
}

// 从缓存加载传输状态（只加载传输中/待处理/暂停的任务）
function loadTransferState() {
  try {
    if (fsSync.existsSync(TRANSFER_STATE_FILE)) {
      const data = fsSync.readFileSync(TRANSFER_STATE_FILE, 'utf8');
      const state = JSON.parse(data);
      
      if (state && state.queue && state.queue.length > 0) {
        // 只加载未完成的任务
        const cachedTasks = state.queue.filter(task => 
          task.status === 'active' || 
          task.status === 'pending' || 
          task.status === 'paused'
        );
        
        if (cachedTasks.length > 0) {
          logger.info(`📂 从缓存加载 ${cachedTasks.length} 个传输任务 (传输中/待处理/暂停)`);
          return { 
            queue: cachedTasks, 
            maxConcurrent: state.maxConcurrent,
            timestamp: Date.now() 
          };
        } else {
          logger.info('缓存中无未完成任务');
        }
      }
    } else {
      logger.info('无缓存文件，没有任务需要恢复');
    }
  } catch (error) {
    logger.error('从缓存加载传输状态失败:', error);
  }
  
  return null;
}

// 创建主窗口
function createWindow() {
  mainWindow = new BrowserWindow({
    width: 1200,
    height: 710,
    resizable: false,
    frame: false, // 完全隐藏原生窗口框架，使用自定义标题栏
    transparent: true, // 启用透明窗口
    webPreferences: {
      nodeIntegration: true,
      contextIsolation: false
    },
    show: false,
    icon: path.join(__dirname, '../../build/icon.png')
  });

  // 检查是否已登录
  const isLoggedIn = config.isLoggedIn();
  const pagePath = isLoggedIn 
    ? path.join(__dirname, '../renderer/base.html')
    : path.join(__dirname, '../renderer/login.html');

  mainWindow.loadFile(pagePath);

  // 页面加载完成后显示窗口
  mainWindow.once('ready-to-show', () => {
    mainWindow.show();
    logger.info('主窗口已显示');
    
    // 如果已经登录，自动连接服务器（系统信息上报已在app.ready时启动）
    if (isLoggedIn) {
      setTimeout(async () => {
        try {
          await connectToServer();
          logger.info('✅ 自动连接服务器成功');
        } catch (error) {
          logger.error('自动连接服务器失败:', error);
        }
      }, 2000); // 延迟2秒，等待界面完全加载
    }
  });

  // 监听加载失败
  mainWindow.webContents.on('did-fail-load', (event, errorCode, errorDescription, validatedURL) => {
    logger.error('页面加载失败:', { errorCode, errorDescription, validatedURL });
  });

  // 将渲染进程的console输出同步到主进程日志
  mainWindow.webContents.on('console-message', (event, level, message, line, sourceId) => {
    const levels = ['debug', 'info', 'warn', 'error'];
    const logLevel = levels[level] || 'info';
    logger[logLevel](`[Renderer] ${message} (${sourceId}:${line})`);
  });

  // 窗口关闭事件（直接退出应用）
  mainWindow.on('close', (event) => {
    // 不再阻止关闭，直接触发应用退出
    if (!app.isQuitting) {
      app.isQuitting = true;
      logger.info('用户点击关闭按钮，准备退出应用');
    }
  });

  mainWindow.on('closed', () => {
    mainWindow = null;
  });

  logger.info('主窗口已创建');
}

// 应用准备就绪
app.on('ready', async () => {
  // 🔥 初始化日志系统：连接 logger 和 logUploader
  logger.setLogUploader(logUploader);
  logger.info('✅ 日志系统已初始化，所有日志将每 12 秒自动上传到服务器');
  
  // 第一步：立即初始化数据库（阻塞式）
  const dbSuccess = initializeDatabase();
  
  if (!dbSuccess) {
    logger.warn('⚠️  数据库初始化失败，将使用JSON文件模式');
  }

  // 🔥 第二步：初始化客户端ID（基于硬件生成）
  try {
    await clientIdManager.initialize();
    logger.info('✅ 客户端ID已初始化:', clientIdManager.getClientId());
  } catch (error) {
    logger.error('❌ 客户端ID初始化失败:', error);
  }

  // 第三步：创建窗口
  createWindow();

  // 🔥 启动时自动清理数据库中的已完成和已取消任务
  if (dbInitialized && database) {
    try {
      logger.info('🧹 清理数据库中的已完成和已取消任务...');
      database.clearCompletedTasks();
      database.clearCancelledTasks();
      logger.info('✅ 数据库清理完成');
    } catch (error) {
      logger.error('数据库清理失败:', error);
    }
  }

  // 恢复传输状态
  const savedState = loadTransferState();
  if (savedState) {
    transferManager.restoreState(savedState);
  }

  // 如果已登录，自动连接
  if (config.isLoggedIn()) {
    try {
      await connectToServer();
    } catch (error) {
      logger.error('自动连接服务器失败:', error);
    }
  }

  // 监听传输进度，实时保存（防止崩溃丢失）
  transferManager.on('save-progress-needed', () => {
    try {
      const state = transferManager.saveState();
      saveTransferState(state);
    } catch (error) {
      logger.error('实时保存传输状态失败:', error);
    }
  });

  // 定期自动保存传输状态（每30秒，作为备份）
  // 延迟5秒后启动，确保所有初始化完成
  setTimeout(() => {
    setInterval(() => {
      try {
        const state = transferManager.saveState();
        saveTransferState(state);
      } catch (error) {
        logger.error('定期保存传输状态失败:', error);
      }
    }, 30000); // 30秒
  }, 5000); // 延迟5秒启动

  // 🔥 启动系统信息上报（应用启动即上报，无需登录）
  // 延迟3秒后启动，确保客户端ID已生成
  setTimeout(() => {
    startSystemInfoReporting();
    logger.info('✅ 系统信息上报已启动（无需登录）');
  }, 3000);

  logger.info('应用已就绪');
});

// 所有窗口关闭
app.on('window-all-closed', () => {
  // macOS下也退出应用
  if (process.platform !== 'darwin') {
    app.quit();
  }
});

app.on('activate', () => {
  if (mainWindow === null) {
    createWindow();
  } else {
    mainWindow.show();
  }
});

// 退出前清理
app.on('before-quit', async () => {
  app.isQuitting = true;
  
  // 🔥 主动通知服务器下线
  try {
    const clientId = clientIdManager.getClientId();
    if (clientId && config.isLoggedIn()) {
      const serverUrl = config.getServerUrl();
      const axios = require('axios');
      
      logger.info('📤 通知服务器客户端下线...');
      
      await axios.post(
        `${serverUrl}/api/clients/offline`,
        { clientId },
        {
          headers: { 'Content-Type': 'application/json' },
          timeout: 3000 // 3秒超时，避免阻塞退出
        }
      );
      
      logger.info('✅ 已通知服务器下线');
    }
  } catch (error) {
    // 忽略错误，不阻塞退出流程
    logger.warn('通知服务器下线失败（忽略）:', error.message);
  }
  
  // 停止系统信息上报
  stopSystemInfoReporting();
  
  // 停止日志上传器
  logUploader.stop();
  
  // 保存传输状态到数据库
  const state = transferManager.saveState();
  saveTransferState(state);
  
  // 清理资源
  transferManager.cleanup();
  websocketClient.disconnect();
  
  // 关闭数据库
  if (dbInitialized && database) {
    try {
      database.close();
      logger.info('数据库已关闭');
    } catch (error) {
      logger.error('关闭数据库失败:', error);
    }
  }
  
  logger.info('应用退出');
});

// 🔥 处理强制退出信号（确保能上报离线状态）
async function handleForceQuit(signal) {
  logger.warn(`⚠️  收到 ${signal} 信号，开始紧急退出流程...`);
  
  // 立即通知服务器下线（最高优先级）
  try {
    const clientId = clientIdManager.getClientId();
    if (clientId) {
      const serverUrl = config.getServerUrl();
      const axios = require('axios');
      
      logger.info('🚨 紧急通知服务器客户端下线...');
      
      // 使用更短的超时时间
      await Promise.race([
        axios.post(
          `${serverUrl}/api/clients/offline`,
          { clientId },
          {
            headers: { 'Content-Type': 'application/json' },
            timeout: 1000 // 1秒超时，快速响应
          }
        ),
        new Promise((_, reject) => setTimeout(() => reject(new Error('超时')), 1000))
      ]);
      
      logger.info('✅ 紧急下线通知已发送');
    }
  } catch (error) {
    logger.warn('紧急下线通知失败（忽略）:', error.message);
  }
  
  // 快速清理
  try {
    stopSystemInfoReporting();
    websocketClient.disconnect();
    transferManager.cleanup();
  } catch (error) {
    logger.error('快速清理失败:', error);
  }
  
  logger.info(`${signal} 处理完成，退出进程`);
  process.exit(0);
}

// 监听 SIGINT (Ctrl+C)
process.on('SIGINT', () => handleForceQuit('SIGINT'));

// 监听 SIGTERM (kill命令)
process.on('SIGTERM', () => handleForceQuit('SIGTERM'));

// 监听未捕获的异常
process.on('uncaughtException', (error) => {
  logger.error('❌ 未捕获的异常:', error);
  handleForceQuit('uncaughtException');
});

// 监听未处理的Promise拒绝
process.on('unhandledRejection', (reason, promise) => {
  logger.error('❌ 未处理的Promise拒绝:', reason);
  handleForceQuit('unhandledRejection');
});

// 处理自动登出（登录过期）
async function handleAutoLogout() {
  try {
    logger.info('🔒 开始执行自动登出流程...');
    
    // 清理资源
    transferManager.cleanup();
    websocketClient.disconnect();
    
    // 清除用户配置
    config.clearUserConfig();
    
    logger.info('✅ 自动登出完成，重新加载登录页');
    
    // 重新加载登录页
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.loadFile(path.join(__dirname, '../renderer/login.html'));
      
      // 通知用户
      mainWindow.webContents.once('did-finish-load', () => {
        mainWindow.webContents.executeJavaScript(`
          if (typeof showNotification === 'function') {
            showNotification('登录已过期，请重新登录', 'warning');
          } else {
            alert('登录已过期，请重新登录');
          }
        `);
      });
    }
  } catch (error) {
    logger.error('❌ 自动登出失败:', error);
  }
}

// 🔥 系统信息上报定时器
let systemInfoReportTimer = null;

// 🔥 启动系统信息上报
function startSystemInfoReporting() {
  // 清除已存在的定时器
  if (systemInfoReportTimer) {
    clearInterval(systemInfoReportTimer);
  }

  logger.info('🚀 启动系统信息上报...');

  // 立即上报第一次
  reportSystemInfo();

  // 🔥 优化：每60秒上报一次，减少CPU占用
  systemInfoReportTimer = setInterval(() => {
    reportSystemInfo();
  }, 60000); // 60秒
}

// 🔥 停止系统信息上报
function stopSystemInfoReporting() {
  if (systemInfoReportTimer) {
    clearInterval(systemInfoReportTimer);
    systemInfoReportTimer = null;
    logger.info('⏹️  系统信息上报已停止');
  }
}

// 🔥 上报系统信息到服务器（无需登录）
async function reportSystemInfo() {
  try {
    // 获取服务器URL
    const serverUrl = config.getServerUrl();
    if (!serverUrl) {
      logger.warn('服务器URL未配置，跳过系统信息上报');
      return;
    }
    
    // 获取客户端ID
    const clientId = clientIdManager.getClientId();
    if (!clientId) {
      logger.warn('客户端ID未初始化，跳过系统信息上报');
      return;
    }

    // 收集系统信息
    const sysInfo = systemInfo.getSystemInfo();
    if (!sysInfo) {
      logger.warn('获取系统信息失败，跳过上报');
      return;
    }

    // 准备上报数据（包含userId如果已登录）
    const reportData = {
      clientId,
      ...sysInfo
    };

    // 如果已登录，添加userId
    if (config.isLoggedIn()) {
      const userConfig = config.getUserConfig();
      reportData.userId = userConfig.userId;
      logger.info(`📤 上报系统信息 - 客户端ID: ${clientId}, 用户ID: ${userConfig.userId}`);
    } else {
      logger.info(`📤 上报系统信息 - 客户端ID: ${clientId} (未登录)`);
    }

    // 发送到服务器（无需token）
    const axios = require('axios');
    const response = await axios.post(
      `${serverUrl}/api/clients/report`,
      reportData,
      {
        headers: {
          'Content-Type': 'application/json'
        },
        timeout: 10000
      }
    );

    if (response.data.success) {
      logger.info('✅ 系统信息上报成功');
    } else {
      logger.warn('⚠️  系统信息上报失败:', response.data.message);
    }
  } catch (error) {
    // 不影响主流程，只记录错误
    if (error.code === 'ECONNREFUSED') {
      logger.warn('系统信息上报失败: 服务器连接被拒绝');
    } else if (error.code === 'ETIMEDOUT') {
      logger.warn('系统信息上报失败: 连接超时');
    } else {
      logger.error('系统信息上报失败:', error.message);
    }
  }
}

// 连接到服务器
async function connectToServer() {
  try {
    const userConfig = config.getUserConfig();
    
    // 连接WebSocket
    await websocketClient.connect();
    
    // 🔥 获取客户端ID并认证
    const clientId = clientIdManager.getClientId();
    await websocketClient.authenticate(userConfig.userId, userConfig.username, clientId);
    
    // 监听WebSocket的401未授权事件
    websocketClient.on('unauthorized', () => {
      logger.error('🚨 WebSocket检测到登录过期，触发自动登出');
      handleAutoLogout();
    });
    
    // 🔥 监听 WebSocket 心跳超时事件
    websocketClient.on('heartbeat-timeout', () => {
      logger.warn('⚠️ WebSocket 心跳超时，连接可能已断开');
    });
    
    // 🔥 监听 WebSocket 断开事件
    websocketClient.on('disconnected', (reason) => {
      logger.warn(`⚠️ WebSocket 断开连接: ${reason}`);
      
      // 通知渲染进程
      if (mainWindow) {
        mainWindow.webContents.send('server-disconnected', reason);
      }
    });
    
    // 🔥 监听 WebSocket 重连事件
    websocketClient.on('reconnected', () => {
      logger.info('✅ WebSocket 重连成功');
      
      // 通知渲染进程
      if (mainWindow) {
        mainWindow.webContents.send('server-reconnected');
      }
    });
    
    // 🔥 监听 WebSocket 重连尝试事件
    websocketClient.on('reconnecting', (attemptNumber) => {
      logger.info(`🔄 WebSocket 正在尝试重连... (第 ${attemptNumber} 次)`);
    });
    
    // 初始化HTTP客户端池
    const transferConfig = config.getTransferConfig();
    try {
      await transferManager.initHTTPPool(transferConfig.maxConcurrent);
      
      // 监听HTTP客户端的401未授权事件
      transferManager.on('unauthorized', () => {
        logger.error('🚨 检测到登录过期，触发自动登出');
        handleAutoLogout();
      });
    } catch (error) {
      logger.error('⚠️  HTTP客户端池初始化失败，将在需要时自动重试:', error);
    }
    
    // 启动日志上传器
    logUploader.start();
    logger.info('日志上传器已启动');
    
    // 🔔 加载通知列表
    try {
      await notificationManager.loadFromServer();
      logger.info('✅ 已从服务器加载通知');
      
      // 获取未读通知
      const unreadNotifications = notificationManager.getUnreadNotifications();
      if (unreadNotifications.length > 0) {
        logger.info(`📬 检测到 ${unreadNotifications.length} 条未读通知`);
        
        // 延迟2秒后显示第一条未读通知（避免启动时弹窗过多）
        setTimeout(() => {
          if (unreadNotifications.length > 0) {
            showNotificationDialog(unreadNotifications[0]);
            
            // 如果有多条未读通知，通知渲染进程
            if (unreadNotifications.length > 1) {
              if (mainWindow) {
                mainWindow.webContents.send('multiple-unread-notifications', unreadNotifications.length);
              }
            }
          }
        }, 2000);
      }
    } catch (error) {
      logger.error('加载通知列表失败:', error);
    }
    
    logger.info('✅ 已连接到服务器');
    
    // 通知渲染进程
    if (mainWindow) {
      mainWindow.webContents.send('server-connected');
    }
    
    return true;
  } catch (error) {
    logger.error('连接服务器失败:', error);
    throw error;
  }
}

// ==================== IPC通信处理 ====================

// 窗口控制
ipcMain.on('app-quit', () => {
  app.isQuitting = true;
  app.quit();
});

ipcMain.on('app-minimize', () => {
  if (mainWindow) {
    mainWindow.minimize();
  }
});

ipcMain.on('app-maximize', () => {
  if (mainWindow) {
    if (mainWindow.isMaximized()) {
      mainWindow.unmaximize();
    } else {
      mainWindow.maximize();
    }
  }
});

// 标题栏窗口控制（新版）
ipcMain.on('window-minimize', () => {
  if (mainWindow) {
    mainWindow.minimize();
  }
});

ipcMain.on('window-maximize', () => {
  if (mainWindow) {
    if (mainWindow.isMaximized()) {
      mainWindow.unmaximize();
    } else {
      mainWindow.maximize();
    }
  }
});

ipcMain.on('window-unmaximize', () => {
  if (mainWindow) {
    mainWindow.unmaximize();
  }
});

// 用户登录成功后连接服务器
ipcMain.on('user-logged-in', async () => {
  logger.info('收到用户登录成功事件，开始连接服务器...');
  try {
    await connectToServer();
    logger.info('✅ 登录后连接服务器成功');
  } catch (error) {
    logger.error('登录后连接服务器失败:', error);
  }
});

// 获取当前 WebSocket 连接状态
ipcMain.handle('get-ws-connection-status', () => {
  return websocketClient.connected;
});

ipcMain.on('window-close', () => {
  // 关闭窗口时直接退出应用
  logger.info('🚪 收到窗口关闭事件，开始退出应用...');
  app.isQuitting = true;
  if (mainWindow) {
    mainWindow.close();
  }
  app.quit();
});

// 打开通知详情窗口
ipcMain.on('open-notification-detail', (event, notificationId) => {
  logger.info('打开通知详情窗口:', notificationId);
  
  const detailWindow = new BrowserWindow({
    width: 700,
    height: 600,
    minWidth: 600,
    minHeight: 500,
    frame: false,
    show: false,
    backgroundColor: '#ffffff',
    webPreferences: {
      nodeIntegration: true,
      contextIsolation: false,
      enableRemoteModule: true
    }
  });

  // 加载通知详情页面，传递通知ID
  const detailUrl = path.join(__dirname, '../renderer/pages/notification-detail.html');
  detailWindow.loadFile(detailUrl, {
    query: { id: notificationId }
  });

  detailWindow.once('ready-to-show', () => {
    detailWindow.show();
  });

  // 开发模式下打开开发者工具（可选）
  // if (process.env.NODE_ENV === 'development') {
  //   detailWindow.webContents.openDevTools({ mode: 'detach' });
  // }
});

// 监听通知更新事件，广播给主窗口
ipcMain.on('notification-updated', () => {
  if (mainWindow && !mainWindow.isDestroyed()) {
    mainWindow.webContents.send('notification-updated');
    logger.info('通知更新事件已广播到主窗口');
  }
});

// 登录
ipcMain.handle('login', async (event, credentials) => {
  try {
    const { username, password } = credentials;
    const axios = require('axios');
    
    // 调用服务器登录API
    const serverUrl = config.getServerUrl();
    const response = await axios.post(`${serverUrl}/api/auth/user/login`, {
      username,
      password
    });

    if (response.data.success) {
      const { token, user } = response.data.data;
      
      // 下载并缓存头像
      let localAvatarPath = null;
      if (user.avatar_url) {
        try {
          localAvatarPath = await avatarManager.downloadAvatar(user.avatar_url);
          logger.info('[登录] 头像已缓存:', localAvatarPath);
        } catch (error) {
          logger.error('[登录] 头像缓存失败:', error);
        }
      }
      
      // 保存用户信息（包括头像URL和本地路径）
      config.setUserConfig({
        token,
        userId: user.id,
        username: user.username,
        nickname: user.nickname,
        avatarUrl: user.avatar_url,
        avatarPath: localAvatarPath
      });

      logger.logAuth('login', username, true);

      // 连接WebSocket
      await websocketClient.connect();
      
      // 🔥 获取客户端ID并认证
      const clientId = clientIdManager.getClientId();
      await websocketClient.authenticate(user.id, user.username, clientId);
      
      // 初始化HTTP客户端池
      const transferConfig = config.getTransferConfig();
      await transferManager.initHTTPPool(transferConfig.maxConcurrent);

      // 注意：系统信息上报已在应用启动时启动，登录后会自动包含userId

      return { 
        success: true, 
        user: {
          ...user,
          localAvatarPath
        }
      };
    } else {
      throw new Error(response.data.message || '登录失败');
    }
  } catch (error) {
    logger.logAuth('login', credentials.username, false, error.message);
    return { success: false, message: error.response?.data?.message || error.message };
  }
});

// 登出
ipcMain.handle('logout', async () => {
  try {
    // 注意：不停止系统信息上报，客户端仍在运行，继续上报但不包含userId
    
    // 清理资源
    transferManager.cleanup();
    websocketClient.disconnect();
    
    // 清除用户配置
    config.clearUserConfig();
    
    logger.info('用户已登出（系统信息上报继续，但不关联用户）');
    
    // 重新加载登录页
    if (mainWindow) {
      mainWindow.loadFile(path.join(__dirname, '../renderer/login.html'));
    }
    
    return { success: true };
  } catch (error) {
    logger.error('登出失败:', error);
    return { success: false, message: error.message };
  }
});

// 获取服务器状态
ipcMain.handle('get-server-status', async () => {
  const wsStatus = websocketClient.getStatus();
  return {
    connected: wsStatus.connected,
    authenticated: wsStatus.authenticated,
    reconnectAttempts: wsStatus.reconnectAttempts
  };
});

// 获取配置
ipcMain.handle('get-config', (event, key) => {
  switch (key) {
    case 'server':
      return config.getServerConfig();
    case 'transfer':
      return config.getTransferConfig();
    case 'user':
      return config.getUserConfig();
    case 'app':
      return config.getAppConfig();
    default:
      return null;
  }
});

// 更新配置
ipcMain.handle('update-config', (event, key, value) => {
  try {
    switch (key) {
      case 'server':
        config.setServerConfig(value);
        break;
      case 'transfer':
        config.setTransferConfig(value);
        // 更新传输管理器的并发数
        transferManager.maxConcurrent = value.maxConcurrent || 3;
        break;
      case 'app':
        config.setAppConfig(value);
        break;
    }
    return { success: true };
  } catch (error) {
    logger.error('更新配置失败:', error);
    return { success: false, message: error.message };
  }
});

// 获取应用路径
ipcMain.handle('get-app-path', () => {
  return app.getPath('userData');
});

// 获取用户目录
ipcMain.handle('get-home-path', () => {
  return os.homedir();
});

// 获取桌面路径
ipcMain.handle('get-desktop-path', () => {
  return app.getPath('desktop');
});

// 获取文档路径
ipcMain.handle('get-documents-path', () => {
  return app.getPath('documents');
});

// 获取下载路径
ipcMain.handle('get-downloads-path', () => {
  return app.getPath('downloads');
});

// 获取可用磁盘列表（仅 Windows）
ipcMain.handle('get-available-drives', async () => {
  if (process.platform !== 'win32') {
    return [];
  }

  const drives = [];
  // 检查 A: 到 Z: 所有可能的盘符
  const letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
  
  for (const letter of letters) {
    const drivePath = `${letter}:\\`;
    try {
      // 尝试访问磁盘，如果成功说明磁盘存在
      await fs.access(drivePath);
      // 尝试读取目录以确认磁盘可用
      await fs.readdir(drivePath);
      drives.push(`${letter}:`);
    } catch (error) {
      // 磁盘不存在或无法访问，跳过
    }
  }
  
  logger.info('可用磁盘:', drives);
  return drives;
});

// 🔥 获取客户端ID
ipcMain.handle('get-client-id', () => {
  const clientId = clientIdManager.getClientId();
  logger.info('[IPC] 获取客户端ID:', clientId);
  return clientId;
});

// 读取目录
ipcMain.handle('read-directory', async (event, dirPath) => {
  try {
    const items = await fs.readdir(dirPath, { withFileTypes: true });

    const files = await Promise.all(
      items
        .filter(item => item.name !== '.Recycle_bin')  // 过滤掉 .Recycle_bin 文件夹
        .map(async (item) => {
        const itemPath = path.join(dirPath, item.name);
        try {
          const stats = await fs.stat(itemPath);
          return {
            name: item.name,
            path: itemPath,
            isDirectory: item.isDirectory(),
            size: stats.size,
            modified: stats.mtime,
            created: stats.birthtime
          };
        } catch (error) {
          logger.error(`读取文件信息失败: ${itemPath}`, error);
          return null;
        }
      })
    );

    // 过滤掉 null 和 .Recycle_bin
    return files.filter(f => f !== null && f.name !== '.Recycle_bin');
  } catch (error) {
    logger.error('读取目录失败:', error);
    throw error;
  }
});

// 创建目录
ipcMain.handle('create-directory', async (event, dirPath) => {
  try {
    await fs.mkdir(dirPath, { recursive: true });
    return { success: true };
  } catch (error) {
    logger.error('创建目录失败:', error);
    throw error;
  }
});

// 删除文件/目录
ipcMain.handle('delete-path', async (event, targetPath) => {
  try {
    const stats = await fs.stat(targetPath);
    if (stats.isDirectory()) {
      await fs.rmdir(targetPath, { recursive: true });
    } else {
      await fs.unlink(targetPath);
    }
    return { success: true };
  } catch (error) {
    logger.error('删除失败:', error);
    throw error;
  }
});

// 重命名文件/目录
ipcMain.handle('rename-path', async (event, oldPath, newPath) => {
  try {
    await fs.rename(oldPath, newPath);
    return { success: true };
  } catch (error) {
    logger.error('重命名失败:', error);
    throw error;
  }
});

// 获取用户头像路径
ipcMain.handle('get-user-avatar', async () => {
  try {
    const userConfig = config.getUserConfig();
    
    if (userConfig.avatarPath) {
      // 检查本地缓存是否存在
      try {
        await fs.access(userConfig.avatarPath);
        return userConfig.avatarPath;
      } catch {
        // 缓存不存在，尝试重新下载
        if (userConfig.avatarUrl) {
          const newPath = await avatarManager.downloadAvatar(userConfig.avatarUrl);
          config.setUserConfig({ ...userConfig, avatarPath: newPath });
          return newPath;
        }
      }
    }
    
    // 返回默认头像
    return avatarManager.defaultAvatar;
  } catch (error) {
    logger.error('[获取头像] 失败:', error);
    return avatarManager.defaultAvatar;
  }
});

// 获取用户配置
ipcMain.handle('get-user-config', async () => {
  try {
    return config.getUserConfig();
  } catch (error) {
    logger.error('[获取用户配置] 失败:', error);
    return null;
  }
});

// 保存用户签名
ipcMain.handle('save-user-signature', async (event, signature) => {
  try {
    const userConfig = config.getUserConfig();
    config.setUserConfig({ ...userConfig, signature });
    logger.info('[保存签名] 成功:', signature);
    return { success: true };
  } catch (error) {
    logger.error('[保存签名] 失败:', error);
    throw error;
  }
});

// 读取文件内容（用于上传）
ipcMain.handle('read-file', async (event, filePath) => {
  try {
    const buffer = await fs.readFile(filePath);
    return buffer;
  } catch (error) {
    logger.error('读取文件失败:', error);
    throw error;
  }
});

// 写入文件内容（用于下载）
ipcMain.handle('write-file', async (event, filePath, data) => {
  try {
    await fs.writeFile(filePath, data);
    return { success: true };
  } catch (error) {
    logger.error('写入文件失败:', error);
    throw error;
  }
});

// 追加文件内容（用于分片下载）
ipcMain.handle('append-file', async (event, filePath, data) => {
  try {
    await fs.appendFile(filePath, data);
    return { success: true };
  } catch (error) {
    logger.error('追加文件失败:', error);
    throw error;
  }
});

// 检查路径是否存在
ipcMain.handle('path-exists', async (event, targetPath) => {
  try {
    await fs.access(targetPath);
    return true;
  } catch {
    return false;
  }
});

// 获取文件信息
ipcMain.handle('get-file-info', async (event, filePath) => {
  try {
    const stats = await fs.stat(filePath);
    return {
      size: stats.size,
      modified: stats.mtime,
      created: stats.birthtime,
      isDirectory: stats.isDirectory(),
      isFile: stats.isFile()
    };
  } catch (error) {
    logger.error('获取文件信息失败:', error);
    throw error;
  }
});

// 打开文件选择对话框
ipcMain.handle('open-file-dialog', async () => {
  const result = await dialog.showOpenDialog(mainWindow, {
    properties: ['openFile', 'multiSelections']
  });
  return result.filePaths;
});

// 打开文件/文件夹选择对话框（支持文件夹）
ipcMain.handle('open-file-or-folder-dialog', async () => {
  const result = await dialog.showOpenDialog(mainWindow, {
    properties: ['openFile', 'openDirectory', 'multiSelections']
  });
  return result.filePaths;
});

// 打开目录选择对话框（支持选择任意磁盘）
ipcMain.handle('open-directory-dialog', async () => {
  const result = await dialog.showOpenDialog(mainWindow, {
    title: '选择本地目录（可选择任意磁盘）',
    properties: ['openDirectory', 'showHiddenFiles', 'createDirectory'],
    buttonLabel: '选择此文件夹'
  });
  return result.filePaths[0];
});

// 打开保存对话框
ipcMain.handle('open-save-dialog', async (event, defaultPath) => {
  const result = await dialog.showSaveDialog(mainWindow, {
    defaultPath: defaultPath
  });
  return result.filePath;
});

// 远程文件操作（HTTP）
ipcMain.handle('remote-list', async (event, dirPath) => {
  try {
    const client = await transferManager.getAvailableClient();
    if (!client) {
      throw new Error('无法连接到服务器，请确保服务器已启动并重试');
    }
    const list = await client.list(dirPath);
    return { success: true, data: list };
  } catch (error) {
    logger.error('列出远程目录失败:', error);
    return { success: false, message: error.message };
  }
});

ipcMain.handle('remote-mkdir', async (event, dirPath) => {
  try {
    const client = await transferManager.getAvailableClient();
    if (!client) {
      throw new Error('无法连接到服务器，请确保服务器已启动并重试');
    }
    await client.mkdir(dirPath);
    return { success: true };
  } catch (error) {
    logger.error('创建远程目录失败:', error);
    return { success: false, message: error.message };
  }
});

ipcMain.handle('remote-delete', async (event, fileId) => {
  try {
    const client = await transferManager.getAvailableClient();
    if (!client) {
      throw new Error('无法连接到服务器，请确保服务器已启动并重试');
    }
    await client.deleteFile(fileId);
    return { success: true };
  } catch (error) {
    logger.error('删除远程文件失败:', error);
    return { success: false, message: error.message };
  }
});

// 传输任务管理
ipcMain.handle('add-upload-task', (event, localPath, remotePath) => {
  const taskId = transferManager.addUploadTask(localPath, remotePath);
  return { success: true, taskId };
});

// 上传文件夹 - 🔥 使用分批传输，每批500个文件
ipcMain.handle('upload-folder', async (event, localFolderPath, remoteFolderPath) => {
  try {
    const client = await transferManager.getAvailableClient();
    if (!client) {
      throw new Error('无法连接到服务器，请确保服务器已启动并重试');
    }

    logger.info(`开始扫描文件夹: ${localFolderPath} -> ${remoteFolderPath}`);

    // 扫描文件夹获取所有文件
    const files = await client.scanFolder(localFolderPath);
    
    // 🔥 防御性检查：确保返回的是数组
    if (!files || !Array.isArray(files)) {
      logger.error('扫描文件夹返回结果异常，不是有效的数组');
      return {
        success: false,
        message: '扫描文件夹失败：返回结果异常'
      };
    }
    
    if (files.length === 0) {
      return {
        success: true,
        message: '文件夹为空',
        data: { taskIds: [], totalFiles: 0, batchId: null }
      };
    }

    logger.info(`扫描到 ${files.length} 个文件`);

    // 收集所有需要创建的目录
    const dirsToCreate = new Set();
    const fileTaskList = [];

    // 首先创建主文件夹
    try {
      await client.mkdir(remoteFolderPath);
      logger.info(`✅ 已创建主文件夹: ${remoteFolderPath}`);
    } catch (error) {
      logger.warn(`创建主文件夹失败: ${error.message}`);
    }

    // 为每个文件准备上传信息
    for (const file of files) {
      const relativePath = path.relative(localFolderPath, file.path);
      const normalizedRelative = relativePath.replace(/\\/g, '/');
      const remoteFilePath = path.posix.join(remoteFolderPath, normalizedRelative);
      const remoteDir = path.posix.dirname(remoteFilePath);

      logger.debug(`文件路径映射: ${file.name} -> ${remoteFilePath}`);

      // 收集目录
      if (remoteDir !== remoteFolderPath && remoteDir !== '/' && remoteDir !== '.') {
        let currentDir = remoteDir;
        while (currentDir && currentDir !== '/' && currentDir !== remoteFolderPath && currentDir !== '.') {
          dirsToCreate.add(currentDir);
          currentDir = path.posix.dirname(currentDir);
        }
      }

      // 添加到文件任务列表
      fileTaskList.push({
        localPath: file.path,
        remotePath: remoteFilePath,
        size: file.size,
        name: file.name
      });
    }

    // 按深度排序并创建目录
    const sortedDirs = Array.from(dirsToCreate).sort((a, b) => {
      return a.split('/').length - b.split('/').length;
    });

    logger.info(`需要创建 ${sortedDirs.length} 个子目录`);
    for (const dir of sortedDirs) {
      try {
        await client.mkdir(dir);
        logger.info(`✅ 已创建目录: ${dir}`);
      } catch (error) {
        logger.warn(`创建目录失败（可能已存在）: ${dir} - ${error.message}`);
      }
    }

    // 🔥 使用分批添加任务（每批500个）
    logger.info(`🔥 开始分批添加上传任务，共 ${fileTaskList.length} 个文件`);
    
    const batchResult = transferManager.addUploadTasksInBatches(fileTaskList);

    logger.info(`✅ 文件夹扫描完成，${batchResult.message}`);

    return {
      success: true,
      message: batchResult.message,
      data: {
        batchId: batchResult.batchId,
        totalFiles: batchResult.totalFiles,
        totalBatches: batchResult.totalBatches,
        folderName: path.basename(localFolderPath)
      }
    };
  } catch (error) {
    logger.error('扫描文件夹失败:', error);
    return {
      success: false,
      message: error.message
    };
  }
});

ipcMain.handle('add-download-task', (event, fileId, fileName, fileSize, localPath) => {
  const taskId = transferManager.addDownloadTask(fileId, fileName, fileSize, localPath);
  return { success: true, taskId };
});

ipcMain.handle('pause-task', (event, taskId) => {
  transferManager.pauseTask(taskId);
  return { success: true };
});

ipcMain.handle('resume-task', (event, taskId) => {
  transferManager.resumeTask(taskId);
  return { success: true };
});

ipcMain.handle('cancel-task', (event, taskId) => {
  transferManager.cancelTask(taskId);
  return { success: true };
});

ipcMain.handle('retry-task', (event, taskId) => {
  transferManager.retryTask(taskId);
  return { success: true };
});

ipcMain.handle('pause-all-tasks', () => {
  transferManager.pauseAll();
  return { success: true };
});

ipcMain.handle('resume-all-tasks', () => {
  transferManager.resumeAll();
  return { success: true };
});

ipcMain.handle('cancel-all-tasks', () => {
  transferManager.cancelAll();
  
  // 保存传输状态到磁盘
  const state = transferManager.saveState();
  saveTransferState(state);
  
  return { success: true };
});

ipcMain.handle('clear-completed-tasks', () => {
  transferManager.clearCompleted();
  
  // 🔥 同时从数据库中删除已完成的任务
  if (dbInitialized && database) {
    try {
      database.clearCompletedTasks();
      logger.info('✅ 已从数据库清除已完成任务');
    } catch (error) {
      logger.error('从数据库清除已完成任务失败:', error);
    }
  }
  
  // 保存传输状态到磁盘
  const state = transferManager.saveState();
  saveTransferState(state);
  
  return { success: true };
});

// 获取传输任务（内存中的传输中任务）
ipcMain.handle('get-tasks', () => {
  return transferManager.getTasks();
});

// 从服务器获取传输队列（已完成/失败的任务）
ipcMain.handle('get-server-transfer-tasks', async (event, options = {}) => {
  try {
    const appConfig = config.get();
    if (!appConfig || !appConfig.serverUrl || !appConfig.token) {
      logger.warn('未配置服务器信息，无法获取传输队列');
      return { success: false, message: '未配置服务器信息' };
    }

    const { client_id, type, status, limit = 100, offset = 0 } = options;
    const clientId = client_id || appConfig.clientId;

    const axios = require('axios');
    const params = new URLSearchParams();
    if (clientId) params.append('client_id', clientId);
    if (type) params.append('type', type);
    if (status) params.append('status', status);
    params.append('limit', limit);
    params.append('offset', offset);

    const response = await axios.get(
      `${appConfig.serverUrl}/api/transfer-queue/list?${params.toString()}`,
      {
        headers: {
          'Authorization': `Bearer ${appConfig.token}`
        },
        timeout: 10000
      }
    );

    if (response.data.success) {
      return { success: true, data: response.data.data };
    } else {
      return { success: false, message: response.data.message };
    }
  } catch (error) {
    logger.error('获取服务器传输队列失败:', error.message);
    return { success: false, message: error.message };
  }
});

// 删除服务器端的传输任务
ipcMain.handle('delete-server-transfer-task', async (event, taskId) => {
  try {
    const appConfig = config.get();
    if (!appConfig || !appConfig.serverUrl || !appConfig.token) {
      return { success: false, message: '未配置服务器信息' };
    }

    const axios = require('axios');
    const response = await axios.delete(
      `${appConfig.serverUrl}/api/transfer-queue/${taskId}`,
      {
        headers: {
          'Authorization': `Bearer ${appConfig.token}`
        },
        timeout: 10000
      }
    );

    return response.data;
  } catch (error) {
    logger.error('删除服务器传输任务失败:', error.message);
    return { success: false, message: error.message };
  }
});

ipcMain.handle('get-task', (event, taskId) => {
  return transferManager.getTask(taskId);
});

ipcMain.handle('get-transfer-stats', () => {
  return transferManager.getStats();
});

// 通知管理
ipcMain.handle('get-notifications', () => {
  return notificationManager.getNotifications();
});

ipcMain.handle('get-unread-notifications', () => {
  return notificationManager.getUnreadNotifications();
});

ipcMain.handle('get-unread-count', () => {
  return notificationManager.getUnreadCount();
});

// 获取单个通知详情
ipcMain.handle('get-notification-detail', (event, notificationId) => {
  try {
    const notifications = notificationManager.getNotifications();
    const notification = notifications.find(n => n.id === parseInt(notificationId));
    if (notification) {
      return notification;
    }
    logger.warn('通知不存在:', notificationId);
    return null;
  } catch (error) {
    logger.error('获取通知详情失败:', error);
    return null;
  }
});

// 从服务器加载通知
ipcMain.handle('load-notifications-from-server', async () => {
  try {
    const notifications = await notificationManager.loadFromServer();
    return { success: true, data: notifications };
  } catch (error) {
    logger.error('加载通知失败:', error);
    return { success: false, error: error.message };
  }
});

// 获取服务器未读数量
ipcMain.handle('get-unread-count-from-server', async () => {
  try {
    const count = await notificationManager.getUnreadCountFromServer();
    return { success: true, count };
  } catch (error) {
    logger.error('获取未读数量失败:', error);
    return { success: false, count: 0 };
  }
});

// 标记通知状态（已读/稍后再读）
ipcMain.handle('mark-notification-read', async (event, notificationId, isRead = true) => {
  try {
    await notificationManager.markAsRead(notificationId, isRead);
    return { success: true };
  } catch (error) {
    logger.error('标记通知失败:', error);
    return { success: false, error: error.message };
  }
});

ipcMain.handle('mark-all-notifications-read', () => {
  notificationManager.markAllAsRead();
  return { success: true };
});

ipcMain.handle('delete-notification', (event, notificationId) => {
  notificationManager.deleteNotification(notificationId);
  return { success: true };
});

ipcMain.handle('clear-read-notifications', () => {
  notificationManager.clearRead();
  return { success: true };
});

// 获取日志路径
ipcMain.handle('get-log-path', () => {
  return logger.getLogPath();
});

// 递归读取目录下所有文件
ipcMain.handle('read-directory-recursive', async (event, dirPath) => {
  const files = [];
  
  async function readDir(currentPath, relativePath = '') {
    try {
      const items = await fs.readdir(currentPath, { withFileTypes: true });
      
      for (const item of items) {
        // 过滤掉 .Recycle_bin 文件夹
        if (item.name === '.Recycle_bin') continue;
        const itemPath = path.join(currentPath, item.name);
        const itemRelativePath = path.join(relativePath, item.name);
        
        try {
          const stats = await fs.stat(itemPath);
          
          if (item.isDirectory()) {
            // 递归读取子目录
            await readDir(itemPath, itemRelativePath);
          } else {
            // 添加文件信息
            files.push({
              name: item.name,
              path: itemPath,
              relativePath: itemRelativePath,
              size: stats.size,
              isDirectory: false
            });
          }
        } catch (error) {
          logger.error(`读取文件信息失败: ${itemPath}`, error);
        }
      }
    } catch (error) {
      logger.error(`读取目录失败: ${currentPath}`, error);
    }
  }
  
  await readDir(dirPath);
  return files;
});

// ==================== 事件监听和转发 ====================

// WebSocket事件监听
websocketClient.on('connected', () => {
  if (mainWindow) {
    mainWindow.webContents.send('ws-connected');
  }
});

websocketClient.on('disconnected', (reason) => {
  if (mainWindow) {
    mainWindow.webContents.send('ws-disconnected', reason);
  }
});

websocketClient.on('reconnecting', (attemptNumber) => {
  if (mainWindow) {
    mainWindow.webContents.send('ws-reconnecting', attemptNumber);
  }
});

websocketClient.on('notification', async (notification) => {
  // 添加到通知管理器
  const notif = notificationManager.addNotification(notification);
  
  // 发送给渲染进程
  if (mainWindow) {
    mainWindow.webContents.send('notification-received', notification);
  }

  // 🔔 显示通知弹窗
  showNotificationDialog(notif);
});

// 🔥 监听服务器请求客户端目录
websocketClient.on('request-directory', async (data, callback) => {
  try {
    logger.info(`📂 服务器请求目录: ${data.path}`);
    
    const dirPath = data.path || os.homedir();
    const items = await fs.readdir(dirPath, { withFileTypes: true });

    const files = await Promise.all(
      items
        .filter(item => item.name !== '.Recycle_bin')  // 过滤掉 .Recycle_bin 文件夹
        .map(async (item) => {
        const fullPath = path.join(dirPath, item.name);
        try {
          const stats = await fs.stat(fullPath);
          return {
            name: item.name,
            path: fullPath,
            isDirectory: item.isDirectory(),
            size: item.isDirectory() ? 0 : stats.size,
            modified: stats.mtime
          };
        } catch (error) {
          logger.error(`获取文件信息失败: ${fullPath}`, error);
          return null;
        }
      })
    );

    // 过滤掉 null 和 .Recycle_bin
    const validFiles = files.filter(f => f !== null && f.name !== '.Recycle_bin');
    
    logger.info(`✅ 返回 ${validFiles.length} 个文件/目录`);
    
    // 返回给服务器
    callback({
      success: true,
      data: {
        path: dirPath,
        files: validFiles
      }
    });
  } catch (error) {
    logger.error('读取目录失败:', error);
    callback({
      success: false,
      message: error.message
    });
  }
});

// 🔥 监听服务器下发传输任务
websocketClient.on('dispatch-transfer-task', async (task, callback) => {
  try {
    logger.info(`📥 收到服务器下发的传输任务:`, task);
    
    const { type, sourcePath, targetPath, files } = task;
    
    // 验证任务参数
    if (!type || !sourcePath || !targetPath || !files || files.length === 0) {
      throw new Error('任务参数不完整');
    }

    // 根据任务类型执行传输
    const taskIds = [];
    
    for (const file of files) {
      const fileSourcePath = path.join(sourcePath, file.name);
      const fileTargetPath = path.join(targetPath, file.name);
      
      if (type === 'upload') {
        // 上传到服务器
        logger.info(`📤 准备上传: ${fileSourcePath} -> ${fileTargetPath}`);
        const taskId = transferManager.addUploadTask(fileSourcePath, fileTargetPath);
        taskIds.push(taskId);
      } else if (type === 'download') {
        // 从服务器下载 - 需要先获取文件信息
        logger.info(`📥 准备下载: ${fileTargetPath} -> ${fileSourcePath}`);
        
        // 对于下载，需要文件ID、文件名、文件大小和本地路径
        // 因为服务器端下发的是客户端路径到服务器路径，所以需要调整
        // 这里假设下载任务是从服务器的targetPath下载到客户端的sourcePath
        try {
          // 获取HTTP客户端
          const client = await transferManager.getAvailableClient();
          if (!client) {
            throw new Error('无法连接到服务器');
          }
          
          // 获取服务器文件信息
          const response = await client.get(`/api/files/info`, {
            params: { path: fileTargetPath }
          });
          
          if (response.data.success) {
            const fileInfo = response.data.data;
            const taskId = transferManager.addDownloadTask(
              fileInfo.id,
              file.name,
              file.size || fileInfo.size,
              fileSourcePath
            );
            taskIds.push(taskId);
          } else {
            throw new Error(`获取文件信息失败: ${response.data.message}`);
          }
        } catch (error) {
          logger.error(`下载任务创建失败: ${error.message}`);
          throw error;
        }
      }
    }
    
    logger.info(`✅ 传输任务已添加: ${taskIds.join(', ')}`);
    
    // 返回成功响应
    callback({
      success: true,
      taskId: taskIds[0], // 返回第一个任务ID
      taskIds: taskIds     // 返回所有任务ID
    });
  } catch (error) {
    logger.error('处理传输任务失败:', error);
    callback({
      success: false,
      message: error.message
    });
  }
});

// 🔥 监听强制登出事件
websocketClient.on('force-logout', (data) => {
  logger.error(`🚨 收到强制登出通知: ${data.reason}`);
  
  // 触发自动登出
  handleAutoLogout();
  
  // 显示提示信息
  if (mainWindow) {
    setTimeout(() => {
      mainWindow.webContents.executeJavaScript(`
        if (typeof alert === 'function') {
          alert('${data.reason}');
        }
      `);
    }, 500);
  }
});

// 传输管理器事件监听
transferManager.on('task-added', (task) => {
  if (mainWindow) {
    mainWindow.webContents.send('task-added', task);
  }
});

transferManager.on('task-started', (task) => {
  if (mainWindow) {
    mainWindow.webContents.send('task-started', task);
  }
});

transferManager.on('task-progress', (task) => {
  if (mainWindow) {
    mainWindow.webContents.send('task-progress', task);
  }
});

transferManager.on('task-completed', (task) => {
  if (mainWindow) {
    mainWindow.webContents.send('task-completed', task);
  }
});

transferManager.on('task-failed', (task) => {
  if (mainWindow) {
    mainWindow.webContents.send('task-failed', task);
  }
});

transferManager.on('task-cancelled', (task) => {
  if (mainWindow) {
    mainWindow.webContents.send('task-cancelled', task);
  }
});

transferManager.on('task-paused', (task) => {
  if (mainWindow) {
    mainWindow.webContents.send('task-paused', task);
  }
});

transferManager.on('task-resumed', (task) => {
  if (mainWindow) {
    mainWindow.webContents.send('task-resumed', task);
  }
});

transferManager.on('all-paused', () => {
  if (mainWindow) {
    mainWindow.webContents.send('all-tasks-paused');
  }
});

transferManager.on('all-resumed', () => {
  if (mainWindow) {
    mainWindow.webContents.send('all-tasks-resumed');
  }
});

transferManager.on('all-cancelled', () => {
  if (mainWindow) {
    mainWindow.webContents.send('all-tasks-cancelled');
  }
});

transferManager.on('completed-cleared', (count) => {
  if (mainWindow) {
    mainWindow.webContents.send('completed-tasks-cleared', count);
  }
});

// 通知管理器事件监听
notificationManager.on('notification-added', (notification) => {
  if (mainWindow) {
    mainWindow.webContents.send('notification-added', notification);
  }
});

notificationManager.on('notification-read', (notification) => {
  if (mainWindow) {
    mainWindow.webContents.send('notification-read', notification);
  }
  
  // 如果当前显示的通知弹窗是这条通知，自动关闭它
  if (currentToastWindow && !currentToastWindow.isDestroyed() && currentToastNotificationId === notification.id) {
    logger.info(`📬 通知已标为已读，自动关闭弹窗: ${notification.id}`);
    currentToastWindow.close();
    currentToastWindow = null;
    currentToastNotificationId = null;
    isShowingNotification = false;
    
    // 延迟显示下一条通知
    setTimeout(() => {
      showNextNotification();
    }, 300);
  }
});

// ==================== 通知弹窗 ====================

// 通知管理
const TOAST_WIDTH = 309; // 266 * 1.16 = 309
const TOAST_HEIGHT = 112; // 108 + 4 = 112
const TOAST_MARGIN = 20;

let currentToastWindow = null; // 当前显示的通知窗口
let currentToastNotificationId = null; // 当前弹窗显示的通知ID
const notificationQueue = []; // 通知队列
let isShowingNotification = false; // 是否正在显示通知
let mainWindowListenersBound = false; // 主窗口监听器是否已绑定

/**
 * 更新通知窗口位置
 */
function updateToastPosition() {
  if (!mainWindow || !currentToastWindow || currentToastWindow.isDestroyed()) return;
  
  const mainWindowBounds = mainWindow.getBounds();
  const toastX = mainWindowBounds.x + mainWindowBounds.width - TOAST_WIDTH - TOAST_MARGIN;
  const toastY = mainWindowBounds.y + TOAST_MARGIN + 35; // 35px 是标题栏高度
  
  currentToastWindow.setPosition(toastX, toastY, false);
}

/**
 * 显示队列中的下一个通知
 */
async function showNextNotification() {
  if (isShowingNotification || notificationQueue.length === 0) return;
  
  // 检查当前是否在消息页面
  try {
    if (mainWindow && !mainWindow.isDestroyed()) {
      const currentView = await mainWindow.webContents.executeJavaScript(
        '(function() { try { return window.currentView || null; } catch(e) { return null; } })()'
      );
      
      // 如果在消息页面，不显示弹窗
      if (currentView === 'message') {
        logger.info(`📬 当前在消息页面，跳过通知弹窗`);
        // 从队列中移除但不显示
        if (notificationQueue.length > 0) {
          notificationQueue.shift();
          // 继续处理下一条
          setTimeout(() => showNextNotification(), 100);
        }
        return;
      }
    }
  } catch (error) {
    logger.error('检查当前页面失败:', error);
  }
  
  const notification = notificationQueue.shift();
  isShowingNotification = true;
  
  showToastWindow(notification);
}

/**
 * 显示通知弹窗（入口函数）
 */
function showNotificationDialog(notification) {
  if (!mainWindow) return;

  const { Notification } = require('electron');
  
  // 🔔 显示系统原生通知
  if (Notification.isSupported()) {
    const nativeNotification = new Notification({
      title: notification.title,
      body: notification.content,
      icon: path.join(__dirname, '../renderer/assets/avatar.png'),
      urgency: notification.priority === 'urgent' ? 'critical' : 'normal'
    });
    
    nativeNotification.show();
    
    nativeNotification.on('click', () => {
      openNotificationDetail(notification.id);
    });
  }
  
  // 检查通知是否已在队列中，避免重复添加
  const existsInQueue = notificationQueue.some(n => n.id === notification.id);
  if (existsInQueue) {
    logger.warn(`⚠️ 通知已在队列中，跳过添加: ${notification.title} (ID: ${notification.id})`);
    return;
  }
  
  // 检查是否是当前正在显示的通知
  if (currentToastNotificationId === notification.id) {
    logger.warn(`⚠️ 通知当前正在显示，跳过添加: ${notification.title} (ID: ${notification.id})`);
    return;
  }
  
  // 添加到队列
  notificationQueue.push(notification);
  logger.info(`📬 通知加入队列: ${notification.title} (队列长度: ${notificationQueue.length})`);
  
  // 尝试显示下一个通知
  showNextNotification();
}

/**
 * 创建并显示通知窗口
 */
function showToastWindow(notification) {
  // 如果已有窗口存在，先关闭它
  if (currentToastWindow && !currentToastWindow.isDestroyed()) {
    currentToastWindow.close();
  }
  
  // 创建自定义通知弹窗
  const mainWindowBounds = mainWindow.getBounds();
  
  // 计算窗口位置
  const toastX = mainWindowBounds.x + mainWindowBounds.width - TOAST_WIDTH - TOAST_MARGIN;
  const toastY = mainWindowBounds.y + TOAST_MARGIN + 35;
  
  currentToastWindow = new BrowserWindow({
    width: TOAST_WIDTH,
    height: TOAST_HEIGHT,
    x: toastX,
    y: toastY,
    frame: false,
    transparent: true,
    alwaysOnTop: true,
    resizable: false,
    skipTaskbar: true,
    show: false,
    parent: mainWindow,
    modal: false,
    hasShadow: false,
    webPreferences: {
      nodeIntegration: true,
      contextIsolation: false,
      enableRemoteModule: true
    }
  });
  
  // 记录当前弹窗显示的通知ID
  currentToastNotificationId = notification.id;
  
  // 准备通知数据
  const notificationData = {
    id: notification.id,
    title: notification.title,
    content: notification.content,
    priority: notification.priority || 'normal'
  };
  
  const toastUrl = path.join(__dirname, '../renderer/pages/notification-toast.html');
  currentToastWindow.loadFile(toastUrl, {
    query: { data: encodeURIComponent(JSON.stringify(notificationData)) }
  });
  
  currentToastWindow.once('ready-to-show', () => {
    currentToastWindow.show();
  });
  
  // 窗口关闭时显示下一个通知
  currentToastWindow.on('closed', () => {
    currentToastWindow = null;
    currentToastNotificationId = null;
    isShowingNotification = false;
    
    // 显示下一个通知
    showNextNotification();
  });
  
  // 主窗口移动时更新通知位置（只绑定一次）
  if (!mainWindowListenersBound && mainWindow && !mainWindow.isDestroyed()) {
    mainWindow.on('move', updateToastPosition);
    mainWindow.on('resize', updateToastPosition);
    mainWindowListenersBound = true;
  }
  
  logger.info(`📬 显示通知弹窗: ${notification.title}`);
}

// 处理通知弹窗按钮点击
ipcMain.on('notification-toast-action', (event, data) => {
  const { action, notificationId } = data;
  
  if (action === 'detail') {
    // 查看详情：标记为已读并打开详情窗口
    notificationManager.markAsRead(notificationId, true);
    logger.info(`用户查看详情: ${notificationId}`);
    openNotificationDetail(notificationId);
  } else if (action === 'later') {
    // 稍后再读：不标记已读
    logger.info(`用户选择稍后再读: ${notificationId}`);
  } else if (action === 'close') {
    // 关闭：不标记已读
    logger.info(`用户关闭通知: ${notificationId}`);
  }
});

// 关闭通知弹窗
ipcMain.on('close-notification-toast', (event) => {
  const window = BrowserWindow.fromWebContents(event.sender);
  if (window) {
    window.close();
  }
});

// 打开通知详情窗口
function openNotificationDetail(notificationId) {
  try {
    // 获取通知详情
    const notifications = notificationManager.getNotifications();
    const notification = notifications.find(n => n.id === parseInt(notificationId));
    
    if (!notification) {
      logger.error(`未找到通知: ${notificationId}`);
      return;
    }
    
    // 自动标记为已读
    if (!notification.isRead) {
      notificationManager.markAsRead(parseInt(notificationId), true);
      logger.info(`📖 通知已标为已读: ${notification.title}`);
    }
    
    const detailWindow = new BrowserWindow({
      width: 700,
      height: 600,
      minWidth: 600,
      minHeight: 500,
      frame: false,
      show: false,
      backgroundColor: '#ffffff',
      webPreferences: {
        nodeIntegration: true,
        contextIsolation: false,
        enableRemoteModule: true
      }
    });

    const detailUrl = path.join(__dirname, '../renderer/pages/notification-detail.html');
    
    // 准备通知数据
    const priorityToType = {
      'urgent': 'error',
      'high': 'warning',
      'normal': 'info',
      'low': 'info'
    };
    
    const notificationData = {
      id: String(notification.id),
      title: notification.title,
      message: notification.content,
      timestamp: notification.createdAt,
      type: priorityToType[notification.priority] || 'info',
      read: notification.isRead || true,
      imageUrl: notification.imageUrl || null,
      notificationType: notification.type || 'text' // text, image, both
    };
    
    // 通过 query 参数传递数据
    detailWindow.loadFile(detailUrl, {
      query: { 
        id: String(notificationId),
        data: encodeURIComponent(JSON.stringify(notificationData))
      }
    });

    detailWindow.once('ready-to-show', () => {
      detailWindow.show();
    });
    
    logger.info(`打开通知详情窗口: ${notificationId}`);
  } catch (error) {
    logger.error('打开通知详情窗口失败:', error);
  }
}

logger.info('事件监听器已设置');
